home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / Tickle-4.0 (tcl) / src / mbtoasd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-18  |  10.9 KB  |  457 lines  |  [TEXT/MPS ]
  1. /*
  2. ** This source code was written by Tim Endres
  3. ** Email: time@ice.com.
  4. ** USMail: 8840 Main Street, Whitmore Lake, MI  48189
  5. **
  6. ** Some portions of this application utilize sources
  7. ** that are copyrighted by ICE Engineering, Inc., and
  8. ** ICE Engineering retains all rights to those sources.
  9. **
  10. ** Neither ICE Engineering, Inc., nor Tim Endres, 
  11. ** warrants this source code for any reason, and neither
  12. ** party assumes any responsbility for the use of these
  13. ** sources, libraries, or applications. The user of these
  14. ** sources and binaries assumes all responsbilities for
  15. ** any resulting consequences.
  16. */
  17.  
  18. #pragma segment MACBIN
  19.  
  20. #include <types.h>
  21. #include <toolutils.h>
  22. #include <standardfile.h>
  23.  
  24. #include <fcntl.h>
  25. #include <stdio.h>
  26. #include "asd.h"
  27. #include "mb.h"
  28. #include "defines.h"
  29.  
  30. #undef BLK_SIZE
  31. #define BLK_SIZE 1024
  32. #define iobuffer kBuffer
  33. extern char kBuffer[];
  34. /* static char                iobuffer[BLK_SIZE]; */
  35.  
  36. static long    dlength = 0;
  37. static long    rlength = 0;
  38. static long    cdate = 0;
  39. static long    mdate = 0;
  40.  
  41. /*
  42. ** WARNING ! WARNING ! WARNING !
  43. ** Both of the parameters to this macro
  44. ** are used more than once! Also, I did
  45. ** NOT parenthsize any parameters.
  46. */
  47. #define CHAR4_TO_LONG(char4, long) { \
  48.     long = 0; \
  49.     long += char4 [0]; long <<= 8; \
  50.     long += char4 [1]; long <<= 8; \
  51.     long += char4 [2]; long <<= 8; \
  52.     long += char4 [3]; \
  53.     }
  54.  
  55. macbinary_to_asingle(crnl_flag)
  56. int            crnl_flag;
  57. {
  58. SFReply        mbreply, asreply;
  59. Point        mypoint;
  60. SFTypeList    mytypes;
  61. F_BLK_PTR    mbptr;
  62. char        *ptr;
  63. int            i;
  64. int            blocks;
  65. int            residue;
  66. int            bytes;
  67. int            offset;
  68. FILE        *mbfile, *asfile;
  69. extern int errno;
  70.  
  71.     mypoint.h = mypoint.v = 75;
  72.     MyGetFile(mypoint, "\pMacBinary File:", NULL, -1, mytypes, NULL, &mbreply);
  73.     
  74.     if (!mbreply.good)
  75.         return CANCEL;
  76.     
  77.     MyPutFile(mypoint, "\pApple Single File:", "file.as", NULL, &asreply);
  78.  
  79.     if (!asreply.good)
  80.         return CANCEL;
  81.     
  82.     p2cstr(asreply.fName);
  83.     p2cstr(mbreply.fName);
  84.  
  85.     SetVol(NULL, mbreply.vRefNum);
  86.     mbfile = fopen(mbreply.fName, "r");
  87.     if (mbfile == NULL) {
  88.         Feedback("Error #%d opening macbinary file '%s'.", errno, mbreply.fName);
  89.         return FAILURE;
  90.         }
  91.  
  92.     SetVol(NULL, asreply.vRefNum);
  93.     asfile = fopen(asreply.fName, "w");
  94.     if (asfile == NULL) {
  95.         Feedback("Error #%d opening apple single file '%s'.", errno, asreply.fName);
  96.         fclose(mbfile);
  97.         return FAILURE;
  98.         }
  99.  
  100.     mbptr = (F_BLK_PTR) &mb_header[0];
  101.     bytes = fread(mbptr, 1, MAC_BINARY_HDR_SIZE, mbfile);
  102.     if (bytes != MAC_BINARY_HDR_SIZE) {
  103.         Feedback("Error #%d getting Macbinary header. Too few bytes.", errno);
  104.         fclose(mbfile);
  105.         fclose(asfile);
  106.         return FAILURE;
  107.         }
  108.  
  109.     UBegYield();
  110.  
  111.     RotateCursor(32);
  112.     DoYield();
  113.     
  114.     /* mbptr->flags */
  115.  
  116.     CHAR4_TO_LONG(mbptr->dflen, dlength);
  117.     CHAR4_TO_LONG(mbptr->rflen, rlength);
  118.  
  119.     CHAR4_TO_LONG(mbptr->cdate, cdate);
  120.     CHAR4_TO_LONG(mbptr->mdate, mdate);
  121.  
  122.     Feedback("MacBinary file '%*.*s'",
  123.         mbptr->nlen, mbptr->nlen, mbptr->name);
  124.  
  125.     Feedback("File Type '%4.4s'", mbptr->type);
  126.  
  127.     Feedback("File Creator '%4.4s'", mbptr->creator);
  128.  
  129.     Feedback("Data Fork %d bytes.", dlength);
  130.  
  131.     Feedback("Rsrc Fork %d bytes.", rlength);
  132.  
  133.     cdate = MAC_TO_UNIX_TIME(cdate);
  134.     Feedback("Creation Date [%d] %s", cdate, ctime(&cdate));
  135.  
  136.     mdate = MAC_TO_UNIX_TIME(mdate);
  137.     Feedback("Modification Date [%d] %s", mdate, ctime(&mdate));
  138.  
  139.     RotateCursor(32);
  140.     DoYield();
  141.     
  142.     memcpy(&asd_finder, mbptr->type, sizeof(asd_fndr_fork));
  143.  
  144.     asd_file_head.asd_head.magic = MAGIC_APPLE_SINGLE;
  145.     asd_file_head.asd_head.version = VERSION_APPLE;
  146.     sprintf(asd_file_head.asd_head.filesys, "%-16.16s", "Macintosh");
  147.     asd_file_head.asd_head.entries = 3;
  148.  
  149.     i = 0;
  150.     asd_file_head.asd_entries[i].id = ASDID_FNDR_FORK;
  151.     asd_file_head.asd_entries[i].offset = sizeof(asd_file_hdr);
  152.     asd_file_head.asd_entries[i].length = sizeof(asd_fndr_fork);
  153.  
  154.     i++;
  155.     asd_file_head.asd_entries[i].id = ASDID_RSRC_FORK;
  156.     asd_file_head.asd_entries[i].offset =
  157.             asd_file_head.asd_entries[i-1].offset +
  158.             asd_file_head.asd_entries[i-1].length;
  159.     asd_file_head.asd_entries[i].length = rlength;
  160.  
  161.     i++;
  162.     asd_file_head.asd_entries[i].id = ASDID_DATA_FORK;
  163.     asd_file_head.asd_entries[i].offset =
  164.             asd_file_head.asd_entries[i-1].offset +
  165.             asd_file_head.asd_entries[i-1].length;
  166.     asd_file_head.asd_entries[i].length = dlength;
  167.  
  168.     RotateCursor(32);
  169.     DoYield();
  170.     
  171.     fwrite(&asd_file_head, 1, sizeof(asd_file_hdr), asfile);
  172.     fwrite(&asd_finder, 1, sizeof(asd_fndr_fork), asfile);
  173.     
  174.     offset = MAC_BINARY_HDR_SIZE + (((dlength + BLK_SIZE - 1) >> 7) << 7);
  175.     Feedback("MBRsrc Offset = %ld Data Length %ld", offset, dlength);
  176.     
  177.     fseek(mbfile, offset, SEEK_SET);
  178.     if (rlength > 0) {
  179.         blocks = rlength / BLK_SIZE;
  180.         residue = rlength % BLK_SIZE;
  181.         for ( ; blocks; blocks-- ) {
  182.             RotateCursor(32);
  183.             DoYield();
  184.             if (pause_op)
  185.                 while (pause_op)
  186.                     pausing();
  187.             bytes = fread(iobuffer, 1, BLK_SIZE, mbfile);
  188.             fwrite(iobuffer, 1, BLK_SIZE, asfile);
  189.             }
  190.         if (residue) {
  191.             RotateCursor(32);
  192.             DoYield();
  193.             if (pause_op)
  194.                 while (pause_op)
  195.                     pausing();
  196.             bytes = fread(iobuffer, 1, residue, mbfile);
  197.             fwrite(iobuffer, 1, residue, asfile);
  198.             }
  199.         }
  200.  
  201.     fseek(mbfile, MAC_BINARY_HDR_SIZE, SEEK_SET);
  202.     if (dlength > 0) {
  203.         blocks = dlength / BLK_SIZE;
  204.         residue = dlength % BLK_SIZE;
  205.         for ( ; blocks; blocks-- ) {
  206.             RotateCursor(32);
  207.             DoYield();
  208.             if (pause_op)
  209.                 while (pause_op)
  210.                     pausing();
  211.             bytes = fread(iobuffer, 1, BLK_SIZE, mbfile);
  212.             if (crnl_flag)
  213.                 for (i=bytes, ptr=iobuffer; i; i--, ptr++)
  214.                     if (*ptr == 0x0D) *ptr = 0x0A;
  215.             fwrite(iobuffer, 1, BLK_SIZE, asfile);
  216.             }
  217.         if (residue) {
  218.             RotateCursor(32);
  219.             DoYield();
  220.             if (pause_op)
  221.                 while (pause_op)
  222.                     pausing();
  223.             bytes = fread(iobuffer, 1, residue, mbfile);
  224.             if (crnl_flag)
  225.                 for (i=bytes, ptr=iobuffer; i; i--, ptr++)
  226.                     if (*ptr == 0x0D) *ptr = 0x0A;
  227.             fwrite(iobuffer, 1, residue, asfile);
  228.             }
  229.         }
  230.  
  231.     WatchCursorOn();
  232.  
  233.     fclose(mbfile);
  234.     fclose(asfile);
  235.     
  236.     UInitCursor();
  237.     UEndYield();
  238.  
  239.     return SUCCESS;
  240.     }
  241.  
  242. macbinary_to_adouble(crnl_flag)
  243. int            crnl_flag;
  244. {
  245. SFReply        mbreply, rreply, dreply;
  246. Point        mypoint;
  247. SFTypeList    mytypes;
  248. F_BLK_PTR    mbptr;
  249. char        *ptr;
  250. char        orig[64];
  251. int            i;
  252. int            blocks;
  253. int            residue;
  254. int            bytes;
  255. int            offset;
  256. FILE        *mbfile, *rfile, *dfile;
  257. extern int errno;
  258.  
  259.     mypoint.h = mypoint.v = 75;
  260.     MyGetFile(mypoint, "\pMacBinary File:", NULL, -1, mytypes, NULL, &mbreply);
  261.     
  262.     if (!mbreply.good)
  263.         return CANCEL;
  264.     
  265.     p2cstr(mbreply.fName);
  266.  
  267.     SetVol(NULL, mbreply.vRefNum);
  268.     mbfile = fopen(mbreply.fName, "r");
  269.     if (mbfile == NULL) {
  270.         Feedback("Error #%d opening macbinary file '%s'.", errno, mbreply.fName);
  271.         return FAILURE;
  272.         }
  273.  
  274.     mbptr = (F_BLK_PTR) &mb_header[0];
  275.     bytes = fread(mbptr, 1, MAC_BINARY_HDR_SIZE, mbfile);
  276.     if (bytes != MAC_BINARY_HDR_SIZE) {
  277.         Feedback("Error #%d getting Macbinary header. (%d != %d)",
  278.                     errno, bytes, MAC_BINARY_HDR_SIZE);
  279.         fclose(mbfile);
  280.         return FAILURE;
  281.         }
  282.  
  283.     Feedback("MacBinary Name: '%.*s'", mbptr->nlen, mbptr->name);
  284.  
  285.     sprintf(orig, "%.*s", ( (mbptr->nlen > 29) ? 29 : mbptr->nlen ), mbptr->name);    
  286.     c2pstr(orig);
  287.     MyPutFile(mypoint, "\pApple Double Data File:", orig, NULL, &dreply);
  288.  
  289.     if (! dreply.good)
  290.         return CANCEL;
  291.     
  292.     sprintf(orig, "%%%.*s",
  293.             ( (dreply.fName[0] > 26) ? 26 : dreply.fName[0] ), &dreply.fName[1]);
  294.     c2pstr(orig);
  295.     MyPutFile(mypoint, "\pApple Double Rsrc File:", orig, NULL, &rreply);
  296.  
  297.     if (!rreply.good)
  298.         return CANCEL;
  299.     
  300.     p2cstr(rreply.fName);
  301.     p2cstr(dreply.fName);
  302.     SetVol(NULL, rreply.vRefNum);
  303.     rfile = fopen(rreply.fName, "w");
  304.     if (rfile == NULL) {
  305.         Feedback("Error #%d opening apple double rsrc file '%s'.", errno, rreply.fName);
  306.         fclose(mbfile);
  307.         return FAILURE;
  308.         }
  309.  
  310.     SetVol(NULL, dreply.vRefNum);
  311.     dfile = fopen(dreply.fName, "w");
  312.     if (dfile == NULL) {
  313.         Feedback("Error #%d opening apple double data file '%s'.", errno, dreply.fName);
  314.         fclose(mbfile);
  315.         fclose(rfile);
  316.         return FAILURE;
  317.         }
  318.  
  319.     UBegYield();
  320.  
  321.     RotateCursor(32);
  322.     DoYield();
  323.     
  324.     /* mbptr->flags */
  325.  
  326.     CHAR4_TO_LONG(mbptr->dflen, dlength);
  327.     CHAR4_TO_LONG(mbptr->rflen, rlength);
  328.  
  329.     CHAR4_TO_LONG(mbptr->cdate, cdate);
  330.     CHAR4_TO_LONG(mbptr->mdate, mdate);
  331.  
  332.     Feedback("MacBinary file '%*.*s'",
  333.         mbptr->nlen, mbptr->nlen, mbptr->name);
  334.  
  335.     Feedback("File Type '%4.4s'", mbptr->type);
  336.  
  337.     Feedback("File Creator '%4.4s'", mbptr->creator);
  338.  
  339.     Feedback("Data Fork %d bytes.", dlength);
  340.  
  341.     Feedback("Rsrc Fork %d bytes.", rlength);
  342.  
  343.     cdate = MAC_TO_UNIX_TIME(cdate);
  344.     Feedback("Creation Date [%d] %s", cdate, ctime(&cdate));
  345.  
  346.     mdate = MAC_TO_UNIX_TIME(mdate);
  347.     Feedback("Modification Date [%d] %s", mdate, ctime(&mdate));
  348.  
  349.     RotateCursor(32);
  350.     DoYield();
  351.     
  352.     memcpy(&asd_finder, mbptr->type, sizeof(asd_fndr_fork));
  353.  
  354.     asd_file_head.asd_head.magic = MAGIC_APPLE_DOUBLE;
  355.     asd_file_head.asd_head.version = VERSION_APPLE;
  356.     sprintf(asd_file_head.asd_head.filesys, "%-16.16s", "Macintosh");
  357.  
  358.     i = 0;
  359.     asd_file_head.asd_entries[i].id = ASDID_FNDR_FORK;
  360.     asd_file_head.asd_entries[i].offset = sizeof(asd_file_hdr);
  361.     asd_file_head.asd_entries[i].length = sizeof(asd_fndr_fork);
  362.     i++;
  363.  
  364.     asd_file_head.asd_entries[i].id = ASDID_RSRC_FORK;
  365.     asd_file_head.asd_entries[i].offset =
  366.             asd_file_head.asd_entries[i-1].offset +
  367.             asd_file_head.asd_entries[i-1].length;
  368.     asd_file_head.asd_entries[i].length = rlength;
  369.     i++;
  370.  
  371. #ifdef NEVER_DEFINED
  372.     asd_file_head.asd_entries[i].id = ASDID_DATA_FORK;
  373.     asd_file_head.asd_entries[i].offset =
  374.             asd_file_head.asd_entries[i-1].offset +
  375.             asd_file_head.asd_entries[i-1].length;
  376.     asd_file_head.asd_entries[i].length = dlength;
  377.     i++;
  378. #endif
  379.  
  380.     RotateCursor(32);
  381.     DoYield();
  382.     
  383.     asd_file_head.asd_head.entries = i;
  384.     fwrite(&asd_file_head, 1, sizeof(asd_file_hdr), rfile);
  385.     fwrite(&asd_finder, 1, sizeof(asd_fndr_fork), rfile);
  386.     
  387.     offset = MAC_BINARY_HDR_SIZE + (((dlength + BLK_SIZE - 1) >> 7) << 7);
  388.     Feedback("MB-RSRC Offset = %ld Length %ld", offset, rlength);
  389.     
  390.     fseek(mbfile, offset, SEEK_SET);
  391.     if (rlength > 0) {
  392.         blocks = rlength / BLK_SIZE;
  393.         residue = rlength % BLK_SIZE;
  394.         for ( ; blocks; blocks-- ) {
  395.             RotateCursor(32);
  396.             DoYield();
  397.             if (pause_op)
  398.                 while (pause_op)
  399.                     pausing();
  400.             bytes = fread(iobuffer, 1, BLK_SIZE, mbfile);
  401.             fwrite(iobuffer, 1, BLK_SIZE, rfile);
  402.             }
  403.         if (residue) {
  404.             RotateCursor(32);
  405.             DoYield();
  406.             if (pause_op)
  407.                 while (pause_op)
  408.                     pausing();
  409.             bytes = fread(iobuffer, 1, residue, mbfile);
  410.             fwrite(iobuffer, 1, residue, rfile);
  411.             }
  412.         }
  413.  
  414.     Feedback("MB-DATA Offset = %ld Length %ld", MAC_BINARY_HDR_SIZE, dlength);
  415.     
  416.     fseek(mbfile, MAC_BINARY_HDR_SIZE, SEEK_SET);
  417.     if (dlength > 0) {
  418.         blocks = dlength / BLK_SIZE;
  419.         residue = dlength % BLK_SIZE;
  420.         for ( ; blocks; blocks-- ) {
  421.             RotateCursor(32);
  422.             DoYield();
  423.             if (pause_op)
  424.                 while (pause_op)
  425.                     pausing();
  426.             bytes = fread(iobuffer, 1, BLK_SIZE, mbfile);
  427.             if (crnl_flag)
  428.                 for (i=bytes, ptr=iobuffer; i; i--, ptr++)
  429.                     if (*ptr == 0x0D) *ptr = 0x0A;
  430.             fwrite(iobuffer, 1, BLK_SIZE, dfile);
  431.             }
  432.         if (residue) {
  433.             RotateCursor(32);
  434.             DoYield();
  435.             if (pause_op)
  436.                 while (pause_op)
  437.                     pausing();
  438.             bytes = fread(iobuffer, 1, residue, mbfile);
  439.             if (crnl_flag)
  440.                 for (i=bytes, ptr=iobuffer; i; i--, ptr++)
  441.                     if (*ptr == 0x0D) *ptr = 0x0A;
  442.             fwrite(iobuffer, 1, residue, dfile);
  443.             }
  444.         }
  445.  
  446.     WatchCursorOn();
  447.     
  448.     fclose(mbfile);
  449.     fclose(rfile);
  450.     fclose(dfile);
  451.     
  452.     UInitCursor();
  453.     UEndYield();
  454.  
  455.     return SUCCESS;
  456.     }
  457.